
#include "precompiled/pchkrayserkraw.h"

#include "kernel/nkernelserver.h"
#include "kraw/krawd3d9.h"
#include "kraw/kraw3dinput.h"

#include <d3d9.h>

nNebulaClass( KrawD3D9, "kraw3d" );

//TODO- move to DisplayData
LPDIRECT3D9             g_pD3D       = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9       g_pd3d9Device = NULL; // Our rendering device

//-----------------------------------------------------------------------------

KrawD3D9::KrawD3D9()
{
}

//-----------------------------------------------------------------------------

KrawD3D9::~KrawD3D9()
{
}

//-----------------------------------------------------------------------------

HRESULT InitD3D()
{
    // Create the D3D object, which is needed to create the D3DDevice.
    if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
        return E_FAIL;

    return S_OK;
}

//-----------------------------------------------------------------------------

HRESULT InitD3DDevice( HWND hWnd )
{
    // Set up the structure used to create the D3DDevice. Most parameters are
    // zeroed out. We set Windowed to TRUE, since we want to do D3D in a
    // window, and then set the SwapEffect to "discard", which is the most
    // efficient method of presenting the back buffer to the display.  And 
    // we request a back buffer format that matches the current desktop display 
    // format.
    D3DPRESENT_PARAMETERS d3dpp; 
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

    // Create the Direct3D device. Here we are using the default adapter (most
    // systems only have one, unless they have multiple graphics hardware cards
    // installed) and requesting the HAL (which is saying we want the hardware
    // device rather than a software one). Software vertex processing is 
    // specified since we know it will work on all cards. On cards that support 
    // hardware vertex processing, though, we would see a big performance gain 
    // by specifying hardware vertex processing.
    if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, &g_pd3d9Device ) ) )
    {
        return E_FAIL;
    }

    // Turn off culling, so we see the front and back of the triangle
//    g_pd3d9Device->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

    // Turn off D3D lighting, since we are providing our own vertex colors
    g_pd3d9Device->SetRenderState( D3DRS_LIGHTING, FALSE );

    return S_OK;
}

//-----------------------------------------------------------------------------

VOID Cleanup()
{
    if( g_pd3d9Device != NULL) 
        g_pd3d9Device->Release();

    if( g_pD3D != NULL)
        g_pD3D->Release();
}

//-----------------------------------------------------------------------------

#define GETX(l) (int(l & 0xFFFF))
#define GETY(l) (int(l) >> 16)

LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
    //forward key and mouse messages to Kraw3DInput
    case WM_MOUSEMOVE:
        Kraw3DInput::OnMouseMove(GETX(lParam), GETY(lParam));
        break;
    case WM_KEYDOWN:
        Kraw3DInput::OnKey((unsigned int) wParam, true);
        break;
    case WM_KEYUP:
        Kraw3DInput::OnKey((unsigned int) wParam, false);
        break;
    case WM_LBUTTONDOWN:
        Kraw3DInput::OnMouseButton(GETX(lParam), GETY(lParam), Button_Left, true);
        break;
    case WM_LBUTTONUP:
        Kraw3DInput::OnMouseButton(GETX(lParam), GETY(lParam), Button_Left, false);
        break;
    case WM_RBUTTONDOWN:
        Kraw3DInput::OnMouseButton(GETX(lParam), GETY(lParam), Button_Right, true);
        break;
    case WM_RBUTTONUP:
        Kraw3DInput::OnMouseButton(GETX(lParam), GETY(lParam), Button_Right, false);
        break;

    case WM_DESTROY:
        Cleanup();
        PostQuitMessage( 0 );
        return 0;
/*  case WM_PAINT:
        Render();
        ValidateRect( hWnd, NULL );
        return 0;*/
    }

    return DefWindowProc( hWnd, msg, wParam, lParam );
}

//-----------------------------------------------------------------------------

bool KrawD3D9::Init()
{
    // Initialize Direct3D
    return SUCCEEDED( InitD3D() );

//    return true;
}

//-----------------------------------------------------------------------------

void KrawD3D9::Shutdown()
{
    //UnregisterClass( "D3D Tutorial", GetModuleHandle(NULL) /*wc.hInstance*/ );
}

//-----------------------------------------------------------------------------

bool KrawD3D9::Trigger()
{
    // Enter the message loop
    MSG msg;
    //ZeroMemory( &msg, sizeof(msg) );
    while ( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
    {
        if( GetMessage( &msg, NULL, 0, 0 ) )
        {
            //TODO- TranslateAccelerator ? see nWin32WindowHandler
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
        if ( msg.message == WM_QUIT ) return false;
    }
    
    return true;
}

//-----------------------------------------------------------------------------

bool KrawD3D9::OpenDisplay( Display& display )
{
    if ( g_pD3D == NULL ) return false;

    //can't open a display that is already open
    if ( display.data ) return false;

    // Register the window class
    WNDCLASSEX wc = { 
        sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, 
        GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
        "Krayser Kraw", NULL };
    RegisterClassEx( &wc );

    // Create the application's window
    HWND hWnd = CreateWindow( "Krayser Kraw", "Krayser Kraw Title", //display.title.Get(), 
                              WS_OVERLAPPEDWINDOW,
                              display.left, display.top, display.width, display.height,
                              /*100, 100, 300, 300,*/
                              NULL, NULL, wc.hInstance, NULL );

    if ( SUCCEEDED( InitD3DDevice( hWnd ) ) )
    {
        // Show the window
        ShowWindow( hWnd, SW_SHOWDEFAULT );
        UpdateWindow( hWnd );

        display.data = (void*) hWnd;

        return true;
    }

    return false;
}

//-----------------------------------------------------------------------------

void KrawD3D9::CloseDisplay( Display& /*display*/ )
{
    UnregisterClass( "Krayser Kraw", GetModuleHandle(NULL) /*wc.hInstance*/ );
}

//-----------------------------------------------------------------------------

bool KrawD3D9::BeginRender( Display& display )
{
    if ( !display.data ) return false;

    // Clear the backbuffer to a blue color
    g_pd3d9Device->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );

    // Begin the scene
    if( FAILED( g_pd3d9Device->BeginScene() ) ) return false;

    return true;
}

//-----------------------------------------------------------------------------

void KrawD3D9::EndRender()
{
    // End the scene
    g_pd3d9Device->EndScene();

    // Present the backbuffer contents to the display
    g_pd3d9Device->Present( NULL, NULL, NULL, NULL );
}
